home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 49 / Amiga Format CD49 (2000-01-17)(Future Publishing)(GB)(Track 1 of 3)[!][issue 2000-02].iso / -serious- / comms / other / novia / src / api / novia_io_api.c < prev    next >
Text File  |  1999-12-06  |  22KB  |  884 lines
  1. #include <novia/novia_global.h>
  2. #include <novia/novia_misc.h>
  3. #include <pragma/intuition_lib.h>
  4. #include <pragma/gadtools_lib.h>
  5. #include <pragma/exec_lib.h>
  6. #include <pragma/dos_lib.h>
  7. #include <intuition/intuition.h>
  8. #include <novia/novia_funcs.h>
  9. #include <novia/novia_registers.h>
  10. #include <pragma/noviasys_lib.h>
  11.  
  12. #define DEBUG
  13.  
  14. extern MainPortConfig *mainportconfig;
  15.  
  16. __saveds ASM void nslib_ShowText(REG(a0) char *path);
  17. __saveds ASM void nslib_ShowPart(REG(a0) char *path, REG(d0) long startseek, REG(d1) long size);
  18. __saveds ASM void nslib_SystemMessage(REG(a0) char *text);
  19. __saveds ASM void nslib_SetColor(REG(d0) char newcolor);
  20. __saveds ASM void nslib_SetBColor(REG(d0) char newcolor);
  21. __saveds ASM void nslib_space(REG(d0) char wert);
  22. __saveds ASM void nslib_cleft(REG(d0) char wert);
  23. __saveds ASM void nslib_cright(REG(d0) char wert);
  24. __saveds ASM void nslib_LF();
  25. __saveds ASM char nslib_Getstring(REG(a0) char *bp, REG(a1) char *src, REG(d0) char maxlen, REG(d1) ULONG flags, REG(d2) ULONG sigs);
  26. __saveds ASM char nslib_Getbyte(REG(a0) UBYTE *p, REG(a1) UBYTE *source, REG(d0) char max, REG(d1) ULONG flags, REG(d2) ULONG sigs);
  27. __saveds ASM char nslib_Getword(REG(a0) UWORD *p, REG(a1) UWORD *source, REG(d0) char max, REG(d1) ULONG flags, REG(d2) ULONG sigs);
  28. __saveds ASM char nslib_Getlong(REG(a0) ULONG *p, REG(a1) ULONG *source, REG(d0) char max, REG(d1) ULONG flags, REG(d2) ULONG sigs);
  29. __saveds ASM void nslib_Writeio(REG(a0) char *string, REG(d0) ULONG len);
  30. __saveds ASM void nslib_Writelong(REG(d0) ULONG tolong);
  31. __saveds ASM void nslib_CSI(REG(d0) char csi);
  32. __saveds ASM void nslib_JumpXY(REG(d0) char x, REG(d1) char y);
  33. __saveds ASM void nslib_CLS();
  34. __saveds ASM char nslib_Getline(REG(a0) char *bp, REG(a1) char *src, REG(d0) char maxlen, REG(d1) ULONG flags, REG(d2) ULONG sigs);
  35. __saveds ASM char nslib_Yesno(REG(d0) BOOL vorgabe,REG(d1) ULONG sigs);
  36. __saveds ASM char nslib_AskKey( register __d0 BOOL vorgabe, register __d1 ULONG flags, register __d2 ULONG sigs);
  37. __saveds ASM char nslib_GetChar(REG(a0) char *vorgabe, REG(d0) ULONG sigs);
  38. __saveds ASM char nslib_WaitKey(REG(d0) ULONG sigs);
  39. __saveds ASM void nslib_ChangeScreenStatus(REG(a0) char *string);
  40. __saveds ASM void nslib_ErrorMessage(REG(a0) char *string);
  41. __saveds ASM void nslib_GetCurserPos();
  42. __saveds ASM void nslib_FreeMsg(REG(a0) message *msg);
  43. __saveds ASM void nslib_ReturnMsg(REG(a0) message *msg);
  44. __saveds ASM void nslib_ClearIOBuffer();
  45. __saveds ASM void nslib_vioprintf(REG(a0) char *formatstring, REG(a1) char *args);
  46. __saveds ASM void nslib_PrintDosError(REG(d0) const LONG errorcode);
  47.  
  48. extern struct Task *startrexxprg(char *ProgramName);
  49. extern LONG SN_Send(APTR data, ULONG len);
  50. extern struct Library *NoviaSysBase;
  51.  
  52. __saveds ASM void nslib_ShowText(REG(a0) char *path)
  53. {
  54.     LONG size;
  55.     char *buffer;
  56.     BPTR mulder;
  57.     if ((mulder = Open(path, MODE_OLDFILE)))
  58.     {
  59.         Seek(mulder, 0, OFFSET_END);
  60.         size = Seek(mulder, 0, OFFSET_END);
  61.         Seek(mulder, 0, OFFSET_BEGINNING);
  62.         if ((buffer = AllocVec((ULONG)size + 1, MEMF_ANY | MEMF_CLEAR)))
  63.         {
  64.             Read(mulder, buffer, size);
  65.             ioprintf(buffer, size);
  66.             FreeVec(buffer);
  67.         }
  68.         else
  69.         {
  70.             ioprintf("Can't alloc mem for textbuffer\n");
  71.         }
  72.         Close(mulder);
  73.     }
  74.     else
  75.     {
  76.         ioprintf("Can't open %s.\n",path);
  77.     }
  78. }
  79.  
  80. __saveds ASM void nslib_ShowPart(REG(a0) char *path, REG(d0) long startseek, REG(d1) long size)
  81. {
  82.     char *buffer;
  83.     BPTR mulder;
  84.     if ((mulder=Open(path,MODE_OLDFILE)))
  85.     {
  86.         Seek(mulder,startseek,OFFSET_BEGINNING);
  87.         if ((buffer=AllocVec((ULONG)size+1,MEMF_ANY)))
  88.         {
  89.             Read(mulder,buffer,size-1);
  90.             nslib_Writeio(buffer,size-1);
  91.             FreeVec(buffer);
  92.         }
  93.         Close(mulder);
  94.     }
  95.     else
  96.     {
  97.         ioprintf("Can't open %s.",(char *)path);
  98.     }
  99. }
  100.  
  101. __saveds ASM void nslib_SystemMessage(REG(a0) char *text)
  102. {
  103.     struct PortData *cport=(PortData *)FindTask(NULL)->tc_UserData;
  104.     if (cport)
  105.     {
  106.         char oldcolor=cport->color;
  107.         char oldbcolor=cport->bcolor;
  108.         ioprintf("c7z0%s%c%dz%d\n",text,oldcolor,oldbcolor);
  109.     }
  110. }
  111.  
  112. __saveds ASM void nslib_SetColor(REG(d0) char newcolor)
  113. {
  114.     struct PortData *cport=(PortData *)FindTask(NULL)->tc_UserData;
  115.     if (cport)
  116.     {
  117.         char buffer[10];
  118.         char iocounter=0;
  119.         cport->color=newcolor;
  120.         buffer[iocounter++]=27;                    // CSI
  121.         buffer[iocounter++]=91;                // [
  122.         buffer[iocounter++]=51;                // 3
  123.         buffer[iocounter++]=newcolor+48;
  124.         buffer[iocounter++]=109;                // m
  125.         buffer[iocounter]=0;
  126.         nslib_Writeio(buffer,-1);
  127.     }
  128. }
  129.  
  130. __saveds ASM void nslib_SetBColor(REG(d0) char newcolor)
  131. {
  132.     struct PortData *cport=(PortData *)FindTask(NULL)->tc_UserData;
  133.     if (cport)
  134.     {
  135.         char buffer[10];
  136.         char iocounter=0;
  137.         cport->bcolor=newcolor;
  138.         buffer[iocounter++]=27;                    // CSI
  139.         buffer[iocounter++]=91;                // [
  140.         buffer[iocounter++]=52;                // 4
  141.         buffer[iocounter++]=newcolor+48;
  142.         buffer[iocounter++]=109;                // m
  143.         buffer[iocounter]=0;
  144.         nslib_Writeio(buffer,-1);
  145.     }
  146. }
  147.  
  148. __saveds ASM void nslib_space(REG(d0) char wert)
  149. {
  150.     char test[100],i;
  151.     if (wert>0)
  152.     {
  153.         for (i=0;i<100;i++)test[i]=32;
  154.         nslib_Writeio(test,wert);
  155.     }
  156. }
  157.  
  158. __saveds ASM void nslib_cleft(REG(d0) char wert)
  159. {
  160.     if (wert>0)
  161.         ioprintf("%dD",wert);
  162. }
  163.  
  164. __saveds ASM void nslib_cright(REG(d0) char wert)
  165. {
  166.     char test[10];
  167.     if (wert>0)
  168.     {
  169.         sprintf(test,"%dC",wert);
  170.         nslib_Writeio(test,-1);
  171.     }
  172. }
  173.  
  174. __saveds ASM void nslib_LF()
  175. {
  176.     nslib_Writeio("\n",1);
  177. }
  178.  
  179. __saveds ASM char nslib_Getstring(REG(a0) char *bp, REG(a1) char *src, REG(d0) char maxlen, REG(d1) ULONG flags, REG(d2) ULONG sigs)
  180. {
  181.     return nslib_Getline(bp,src,maxlen,flags,sigs);
  182. }
  183.  
  184.  
  185. __saveds ASM char nslib_Getbyte(REG(a0) UBYTE *p, REG(a1) UBYTE *source, REG(d0) char max, REG(d1) ULONG flags, REG(d2) ULONG sigs)
  186. {
  187.     char buffer1[10];
  188.     char buffer2[10];
  189.     char returncode;
  190.     ULONG ulong;
  191.     sprintf(buffer1,"%d",*source);
  192.     returncode=nslib_Getline(buffer2,buffer1,max,(INPUT_TYPE_NUMBER | flags),sigs);
  193.     StrToLong(buffer2,(LONG *)&ulong);
  194.     p[0]=(UBYTE)ulong;
  195.     return returncode;
  196. }
  197.  
  198. __saveds ASM char nslib_Getword(REG(a0) UWORD *p, REG(a1) UWORD *source, REG(d0) char max, REG(d1) ULONG flags, REG(d2) ULONG sigs)
  199. {
  200.     char buffer1[15];
  201.     char buffer2[15];
  202.     char returncode;
  203.     ULONG ulong;
  204.     sprintf(buffer1,"%d",*source);
  205.     returncode=nslib_Getline(buffer2,buffer1,max,(INPUT_TYPE_NUMBER | flags),sigs);
  206.     StrToLong(buffer2,(LONG *)&ulong);
  207.     p[0]=(UWORD)ulong;
  208.     return returncode;
  209. }
  210.  
  211. __saveds ASM char nslib_Getlong(REG(a0) ULONG *p, REG(a1) ULONG *source, REG(d0) char max, REG(d1) ULONG flags, REG(d2) ULONG sigs)
  212. {
  213.     char buffer1[20];
  214.     char buffer2[20];
  215.     char returncode;
  216.     sprintf(buffer1,"%d",*source);
  217.     returncode=nslib_Getline(buffer2,buffer1,max,(INPUT_TYPE_NUMBER | flags),sigs);
  218.     StrToLong(buffer2,(LONG *)p);
  219.     return returncode;
  220. }
  221.  
  222.  
  223. __saveds ASM void nslib_Writeio(REG(a0) char *string, REG(d0) ULONG len)
  224. {
  225.     struct PortData *cport=(PortData *)FindTask(NULL)->tc_UserData;
  226.     if (cport)
  227.     {
  228.         char *iobuffer=cport->iobuffer;
  229.         long counter=0,iocounter=0,ulong,length,chars;
  230.         IOBuffer *io_entry;
  231.         for (counter=0; (string[counter]!=0 && counter<len) ; counter++)
  232.         {
  233.             if (string[counter]==25)    // MCI Controlcode CTRL-Y
  234.             {
  235.                 if (string[counter+1]>96 && string[counter+1]<123) // convert to upper
  236.                     string[counter+1]=string[counter+1]-32;
  237.                 switch(string[counter+1])
  238.                 {
  239.                     case 'C':            // C (set color)
  240.                         iobuffer[iocounter++]=27;                // CSI
  241.                         iobuffer[iocounter++]=91;                // [
  242.                         iobuffer[iocounter++]=51;                // 3
  243.                         iobuffer[iocounter++]=string[counter+2];// char
  244.                         iobuffer[iocounter++]=109;                // m
  245.                         counter=counter+2;
  246.                         cport->color=string[counter]-48;
  247.                         break;
  248.                     case 'Z':            // Z (set backgroundcolor)
  249.                         iobuffer[iocounter++]=27;                // CSI
  250.                         iobuffer[iocounter++]=91;                // [
  251.                         iobuffer[iocounter++]=52;                // 4
  252.                         iobuffer[iocounter++]=string[counter+2];// char
  253.                         iobuffer[iocounter++]=109;                // m
  254.                         counter=counter+2;
  255.                         cport->bcolor=string[counter]-48;
  256.                         break;
  257.                     case 'V':            // V (Show Variable) 
  258.                                         // Examples: VL003 or VLHandle - Show LocalUser Handle
  259.                                         //              VE003 or VEHandle - Show EditUser Handle
  260.                                         //             VM006 Show GMT-Time
  261.                                         // !!! DIRECT NAMES ARE NOT IMPLEMENTED IN THIS VERSION !!!
  262.                                         //
  263.                         chars=StrToLong(&string[counter+3],(LONG *)&ulong);
  264.                         if (ulong>0 && ulong<=*cport->numberofmci)
  265.                         {
  266.                             char *offset;
  267.                             if (string[counter+2]>96 && string[counter+2]<123) // convert to upper
  268.                                 string[counter+2]=string[counter+2]-32;
  269.     
  270.                             if (string[counter+2]=='U')
  271.                                 offset=(char *)&cport->LocalUser;
  272.                             else
  273.                                 offset=(char *)&cport->EditUser;                            
  274.                             switch (cport->mcicmd[ulong].type)
  275.                             {
  276.                                 case TYPE_BYTE:
  277.                                     sprintf(iobuffer+iocounter,"%d",offset[cport->mcicmd[ulong].offset]);
  278.                                     length=strlen(iobuffer+iocounter);
  279.                                     if (length>0)iocounter=iocounter+length;
  280.                                 break;
  281.                                 case TYPE_WORD:
  282.                                     sprintf(iobuffer+iocounter,"%d",((WORD *)offset)[cport->mcicmd[ulong].offset>>1]);
  283.                                     length=strlen(iobuffer+iocounter);
  284.                                     if (length>0)iocounter=iocounter+length;
  285.                                 break;
  286.                                 case TYPE_LONG:
  287.                                     sprintf(iobuffer+iocounter,"%d",((long *)offset)[cport->mcicmd[ulong].offset>>2]);
  288.                                     length=strlen(iobuffer+iocounter);
  289.                                     if (length>0)iocounter=iocounter+length;
  290.                                 break;
  291.                                 case TYPE_STRING:
  292.                                     sprintf(&iobuffer[iocounter],"%s",offset+cport->mcicmd[ulong].offset);
  293.                                     length=strlen(offset+cport->mcicmd[ulong].offset);
  294.                                     if (length>0)iocounter=iocounter+length;
  295.                                 break;
  296.                             }
  297.                         }
  298.                         if (chars<0)chars=0;
  299.                         counter=counter+2+chars;
  300.                         break;
  301.                     case 'N':            // N (Print n Lines)
  302.                         iobuffer[iocounter++]=27;                // CSI
  303.                         iobuffer[iocounter++]=91;                // [
  304.                         iobuffer[iocounter++]=10;                // LineFeed
  305.                         counter=counter+2;
  306.                         break;
  307.     /*                case 'R':             run a Program
  308.                                            1 - start a internal novia command
  309.                                            2 - start a DOS-Exec-Program
  310.                                            3 - start a NOVIA-Executable (Plugin & PLAY)
  311.                                            4 - start a NOVIA-AREXX-Script
  312.                                            5 - start a "CNETC", Executable
  313.                                            6 - start a CNET-AREXX
  314.     
  315.                                         Example: 3rexxc:wall.rexx start the wall in rexxc:
  316.                         switch(iobuffer[iocounter+2])
  317.                         {
  318.                             buffer2[100];
  319.                             for (ulong=0;((ulong<90) && (!(iobuffer[iocounter+3+ulong]==')')));ulong++)
  320.                                 buffer2[ulong]=iobuffer[iocounter+3+ulong];
  321.                             buffer2[ulong]=0;
  322.                         case 1:
  323.                             GetArg(buffer2);
  324.                             if (!StdCommand(GetCommandID(argstring[0])))
  325.                                 ioprintf("error: unknown command %s\n",buffer2);
  326.                             break;
  327.                         case 2:
  328.                             break;
  329.                         case 3:
  330. #ifdef DEBUG
  331.                             printf("RUN REXX: %d",buffer2);
  332. #endif
  333.                             break;
  334.                         case 4:
  335.                             break;
  336.                         case 5:
  337.                             break;
  338.                         case 6:
  339.                             break;
  340.                         }*/
  341.                     case 'T':            // Print a textfile
  342.                         break;
  343.                 }
  344.             }
  345.             else
  346.             {
  347.                 if (string[counter] == 9)                // FORWARD-TAB
  348.                 {
  349. /*                    iobuffer[iocounter++] = ' ';
  350.                     iobuffer[iocounter++] = ' ';*/
  351.                     iobuffer[iocounter] = ' ';
  352.                 }
  353.                 else
  354.                     iobuffer[iocounter]=string[counter];
  355.                 iocounter++;
  356.             }
  357.         }
  358.         iobuffer[iocounter]=0;
  359.         if (cport->win)
  360.         {
  361.             cport->ConWrite->io_Data        = iobuffer; 
  362.             cport->ConWrite->io_Length        = iocounter;
  363.               cport->ConWrite->io_Command    = CMD_WRITE;
  364.             DoIO((IORequest *)cport->ConWrite);
  365.         }
  366. //        if (cport->network.isopen && cport->network.can_write && cport->network.online)
  367. //            SN_Send(iobuffer, iocounter);
  368.     }
  369. }
  370.  
  371. __saveds ASM void nslib_Writelong(REG(d0) ULONG tolong)
  372. {
  373.     char buffer[15];
  374.     sprintf(buffer,"%d",tolong);
  375.     nslib_Writeio(buffer,-1);
  376. }
  377.  
  378. __saveds ASM void nslib_CSI(REG(d0) char csi)
  379. {
  380.     char *buffer=" ";
  381.     buffer[1]=csi;
  382.     nslib_Writeio(buffer,1);
  383. }
  384.  
  385. __saveds ASM void nslib_JumpXY(REG(d0) char x, REG(d1) char y)
  386. {
  387.     char buffer[10];
  388.     sprintf(buffer,"%d;%dH",y,x);
  389.     nslib_Writeio(buffer,-1);
  390. }
  391.  
  392. __saveds ASM void nslib_CLS()
  393. {
  394.     nslib_Writeio("H",-1);    // erase the screen
  395. }
  396.  
  397. __saveds ASM char nslib_Getline(REG(a0) char *bp, REG(a1) char *src, REG(d0) char maxlen, REG(d1) ULONG flags, REG(d2) ULONG sigs)
  398. {
  399.     struct PortData *cport=(PortData *)FindTask(NULL)->tc_UserData;
  400.     if (cport)
  401.     {
  402.         char cp[80];
  403.         char bp2[80];
  404.         char pos=0;
  405.         char end=0;
  406.         BOOL Quit=FALSE;
  407.         BOOL habschon;
  408.         BOOL change=FALSE;
  409.         int i;
  410.         char wert;
  411.         short counter;
  412.         List *his_list=(List *)&cport->his_list;
  413.         struct HisEntry *hisentry=(HisEntry *)his_list->lh_TailPred;
  414.         BOOL first=FALSE;
  415.         BOOL ende=FALSE;
  416.         *bp=0;
  417.         nslib_Writeio("c3",-1);
  418.         if (src!=0)
  419.         {
  420.             strcpy(bp,src);
  421.             end=strlen(bp);
  422.             nslib_Writeio(bp,-1);
  423.             pos=end;
  424.         }
  425.         
  426.         bp[end]=0;
  427.         while(!Quit && cport->network.online)
  428.         {
  429.             habschon=FALSE;
  430.             Conread(cp,1,sigs);
  431.             if (*cp==13)
  432.             {
  433.                 *cp=10;
  434.                 nslib_Writeio(cp,1);
  435.                 if ((flags & BUFFERED) && end)
  436.                 {
  437.                     if (cport->hiscounter<50)
  438.                         cport->hiscounter++;
  439.                     else
  440.                     {
  441.                         FreeVec(RemHead(his_list));
  442.                     }
  443.                     if (hisentry=AllocVec(sizeof(HisEntry),MEMF_ANY|MEMF_CLEAR))
  444.                     {
  445.                         strncpy(hisentry->buffer,bp,80);
  446.                         AddTail(his_list,(Node *)hisentry);
  447.                     }
  448.                 }
  449.                 Quit=TRUE;
  450.             }
  451.             if (*cp==9 && (flags & TAB_FORWARD))
  452.                 return TAB_FORWARD;
  453.             if (*cp==-101)
  454.             {
  455.                 Conread(cp,1,sigs);
  456.                 switch (*cp)
  457.                 {
  458.                     case 'Z':            // TAB-Backward
  459.                         if (flags & TAB_BACKWARD)
  460.                             return TAB_BACKWARD;
  461.                         break;
  462.                     case 'D':
  463.                         if (pos>0)
  464.                         {
  465.                             nslib_Writeio("D",-1);
  466.                             pos--;
  467.                          }
  468.                         break;
  469.                     case 'C':
  470.                         if (pos<end && end<=maxlen)
  471.                         {
  472.                             nslib_Writeio("C",-1);
  473.                             pos++;
  474.                         }
  475.                         break;
  476.                     case 'A':
  477.                         if (flags & CURSER_BREAK)
  478.                         {
  479.                             return ESC_UP;
  480.                         }
  481.                         else if (flags & BUFFERED)
  482.                         {
  483.                             if (hisentry && hisentry->ln_Succ && hisentry->ln_Pred)
  484.                             {
  485.                                 nslib_cleft(pos);
  486.                                 nslib_space(end);
  487.                                 nslib_cleft(end);
  488.                                 if (first)
  489.                                 {
  490.                                     if (hisentry->ln_Pred->ln_Pred)
  491.                                     {
  492.                                         hisentry=hisentry->ln_Pred;
  493.                                         strcpy(bp,hisentry->buffer);
  494.                                         end=strlen(bp);
  495.                                         nslib_Writeio(bp,-1);
  496.                                         pos=end;
  497.                                     }
  498.                                     else
  499.                                     {
  500.                                         ClearMemQuick(bp,80);
  501.                                         end=0;
  502.                                         pos=0;
  503.                                         ende=TRUE;
  504.                                     }
  505.                                 }
  506.                                 else
  507.                                 {
  508.                                     strcpy(bp,hisentry->buffer);
  509.                                     end=strlen(bp);
  510.                                     nslib_Writeio(bp,-1);
  511.                                     pos=end;
  512.                                     first=TRUE;
  513.                                 }
  514.                             }
  515.                         }
  516.                         break;
  517.                     case 'B':
  518.                         if (flags & CURSER_BREAK)
  519.                             return ESC_DOWN;
  520.                         else if (flags & BUFFERED)
  521.                         {
  522.                             if (hisentry && hisentry->ln_Succ && hisentry->ln_Pred)
  523.                             {
  524.                                 nslib_cleft(pos);
  525.                                 nslib_space(end);
  526.                                 nslib_cleft(end);
  527.                                 if (ende)
  528.                                 {
  529.                                     strcpy(bp,hisentry->buffer);
  530.                                     end=strlen(bp);
  531.                                     nslib_Writeio(bp,-1);
  532.                                     pos=end;
  533.                                     first=TRUE;
  534.                                     ende=FALSE;
  535.                                 }
  536.                                 else
  537.                                 {
  538.                                     if (hisentry->ln_Succ->ln_Succ)
  539.                                     {
  540.                                         hisentry=hisentry->ln_Succ;
  541.                                         strcpy(bp,hisentry->buffer);
  542.                                         end=strlen(bp);
  543.                                         nslib_Writeio(bp,-1);
  544.                                         pos=end;
  545.                                     }
  546.                                     else
  547.                                     {
  548.                                         ClearMemQuick(bp,80);
  549.                                         end=0;
  550.                                         pos=0;
  551.                                         first=FALSE;
  552.                                     }
  553.                                 }
  554.                             }
  555.                         }
  556.                         break;
  557.                 }
  558.                 habschon=TRUE;
  559.                 change=TRUE;
  560.             }
  561.             if (*cp==8 && pos>0 && habschon==FALSE)
  562.             {
  563.                 nslib_Writeio(cp,1);
  564.                 pos--;
  565.                 for (i=pos;i<end;i++)
  566.                 {
  567.                     bp[i]=bp[i+1];
  568.                 }
  569.                 end--;
  570.                 nslib_Writeio(&bp[pos],end-pos);
  571.                 nslib_Writeio(" ",1);
  572.                 nslib_cleft((end-pos)+1);
  573.                 habschon=TRUE;
  574.                 change=TRUE;
  575.             }
  576.             if (*cp==127 && pos<end && habschon==FALSE)
  577.             {
  578.                 for (i=pos;i<end;i++)
  579.                 {
  580.                     bp[i]=bp[i+1];
  581.                 }
  582.                 end--;
  583.                 nslib_Writeio(&bp[pos],end-pos);
  584.                 nslib_Writeio(" ",1);
  585.                 nslib_cleft((end-pos)+1);
  586.                 habschon=TRUE;
  587.                 change=TRUE;
  588.             }
  589.             if (((*cp>=-96 && *cp<0) | (*cp>=32 && *cp<127)) && end<maxlen && pos<maxlen && habschon==FALSE)
  590.             {
  591.                 if ((!(flags & INPUT_TYPE_NUMBER))| (*cp>47 && *cp<58))
  592.                 {
  593.                     if (pos==end)
  594.                     {
  595.                         if (change==FALSE && pos>0)
  596.                         {
  597.                             nslib_cleft(pos);
  598.                             nslib_space(end);
  599.                             nslib_cleft(end);
  600.                             pos=1;
  601.                             end=1;
  602.                             bp[1]=0;
  603.                             bp[0]=*cp;
  604.                             nslib_Writeio(cp,1);
  605.                         }
  606.                         else
  607.                         {
  608.                             nslib_Writeio(cp,1);
  609.                             bp[pos]=*cp;
  610.                             pos++;
  611.                             end++;
  612.                             bp[end]=0;
  613.                         }
  614.                     }
  615.                     else
  616.                     {
  617.                         for (i=end;i>=pos;i--)
  618.                         {
  619.                             bp[i+1]=bp[i];
  620.                         }
  621.                         end++;
  622.                         bp[pos]=*cp;
  623.                         bp[end]=0;
  624.                         ioprintf("%dCP%dD@%c",end-pos,end-pos,*cp);
  625.                         pos++;
  626.                     }
  627.                     change=TRUE;
  628.                     habschon=TRUE;
  629.                     bp[end]=0;
  630.                 }
  631.             }
  632.             if (pos==0 && end==0 && (flags & CURSER_BREAK))Quit=TRUE;
  633.         }
  634.         bp[end]=0;
  635.         bp[end+1]=0;
  636.         if (flags & BUFFERED)
  637.         {
  638.         }
  639.     }
  640.     else
  641.         return NULL;
  642. }
  643.  
  644. __saveds ASM char nslib_Yesno(REG(d0) BOOL vorgabe,REG(d1) ULONG sigs)
  645. {
  646.     struct PortData *cport=(PortData *)FindTask(NULL)->tc_UserData;
  647.     if (cport)
  648.     {
  649.         char Quit=FALSE;
  650.         char buffer[10];
  651.         if (vorgabe==TRUE)nslib_Writeio("[Yes] ",-1);
  652.         if (vorgabe==FALSE)nslib_Writeio("[No ] ",-1);
  653.         while (!Quit && cport->network.online)
  654.         {
  655.             Conread(buffer,1,sigs);
  656.             if (*buffer==89 | *buffer==121)    // ASCII Y & y
  657.                 {
  658.                     nslib_Writeio("Yes\n",-1);
  659.                     return TRUE;
  660.                 }
  661.             if (*buffer==78 | *buffer==110) // ASCII N & n
  662.                 {
  663.                     nslib_Writeio("No\n",-1);
  664.                     return FALSE;
  665.                 }
  666.             if (*buffer==13 | *buffer==0)
  667.             {
  668.                 if (vorgabe==TRUE)
  669.                 {
  670.                     nslib_Writeio("Yes\n",-1);
  671.                     return TRUE;
  672.                 }
  673.                 if (vorgabe==FALSE)
  674.                 {
  675.                     nslib_Writeio("No\n",-1);
  676.                     return FALSE;
  677.                 }
  678.             }
  679.         }
  680.     }
  681. }
  682.  
  683. __saveds ASM char nslib_AskKey( register __d0 BOOL vorgabe, register __d1 ULONG flags, register __d2 ULONG sigs)
  684. {
  685.     struct PortData *cport=(PortData *)FindTask(NULL)->tc_UserData;
  686.     char result = 0;
  687.     char buffer[10];
  688.     if (cport && flags)
  689.     {
  690.         while (!result && cport->network.online)
  691.         {
  692.             Conread(buffer,1,sigs);
  693.             if ((*buffer=='Y' | *buffer=='y') && (flags & FLAG_YES))
  694.             {
  695.                 nslib_Writeio("Yes\n",-1);
  696.                 result = RESULT_YES;
  697.             }
  698.             if ((*buffer=='N' | *buffer=='n') && (flags & FLAG_NO))
  699.             {
  700.                 nslib_Writeio("No\n",-1);
  701.                 result = RESULT_NO;
  702.             }
  703.             if ((*buffer=='A' | *buffer=='a') && (flags & FLAG_ALL))
  704.             {
  705.                 nslib_Writeio("All\n",-1);
  706.                 result = RESULT_ALL;
  707.             }
  708.             if ((*buffer=='C' | *buffer=='c') && (flags & FLAG_CANCEL))
  709.             {
  710.                 nslib_Writeio("Cancel\n",-1);
  711.                 result = RESULT_CANCEL;
  712.             }
  713.             if ((*buffer=='Q' | *buffer=='q') && (flags & FLAG_QUIT))
  714.             {
  715.                 nslib_Writeio("Quit\n",-1);
  716.                 result = RESULT_QUIT;
  717.             }
  718.             if (*buffer==13 | *buffer==10)
  719.             {
  720.                 if (vorgabe)
  721.                 {
  722.                     switch(vorgabe)
  723.                     {
  724.                         case RESULT_YES:
  725.                             nslib_Writeio("Yes\n",-1);
  726.                             result = RESULT_YES;
  727.                             break;
  728.                         case RESULT_NO:
  729.                             nslib_Writeio("No\n",-1);
  730.                             result = RESULT_NO;
  731.                             break;
  732.                         case RESULT_ALL:
  733.                             nslib_Writeio("Yes\n",-1);
  734.                             result = RESULT_ALL;
  735.                             break;
  736.                         case RESULT_CANCEL:
  737.                             nslib_Writeio("Cancel\n",-1);
  738.                             result = RESULT_CANCEL;
  739.                             break;
  740.                         case RESULT_QUIT:
  741.                             nslib_Writeio("Quit\n",-1);
  742.                             result = RESULT_QUIT;
  743.                             break;
  744.                     }
  745.                 }
  746.             }
  747.         }
  748.     }
  749.     return result;
  750. }
  751.  
  752.  
  753. __saveds ASM char nslib_GetChar(REG(a0) char *vorgabe, REG(d0) ULONG sigs)
  754. {
  755.     struct PortData *cport=(PortData *)FindTask(NULL)->tc_UserData;
  756.     if (cport)
  757.     {
  758.         char buffer[10];
  759.         while (cport->network.online)
  760.         {
  761.             Conread(buffer,1,sigs);
  762.             if (*buffer==13) return *vorgabe;
  763.             if (*buffer)return *buffer;
  764.         }
  765.     }
  766.     return FALSE;
  767. }
  768.  
  769. __saveds ASM char nslib_WaitKey(REG(d0) ULONG sigs)
  770. {
  771.     char buffer[10];
  772.     Conread(buffer,1,sigs);
  773.     return NULL;
  774. }
  775.  
  776. __saveds ASM void nslib_ChangeScreenStatus(REG(a0) char *string)
  777. {
  778. /*    strcpy(screentitel+titellen,string);
  779.     if (win)
  780.     {
  781.         SetWindowTitles(win,NULL,screentitel);
  782.     }*/
  783. }
  784.  
  785. __saveds ASM void nslib_ErrorMessage(REG(a0) char *string)
  786. {
  787.     nslib_Writeio(string,-1);
  788.     VPrintf(string,0);
  789.     VPrintf("\n",0);
  790. };
  791.  
  792. __saveds ASM void nslib_GetCurserPos()
  793. {
  794.     struct PortData *cport=(PortData *)FindTask(NULL)->tc_UserData;
  795.     if (cport)
  796.     {
  797.         long *longbuffer;
  798.         char bp[5];
  799.         char cp[10];
  800.         char pos=0;
  801.         BOOL Quit=FALSE;
  802.         *bp=0;
  803.         nslib_Writeio("n",-1);
  804.         while(!Quit && cport->network.online)
  805.         {
  806.             Conread(cp,1,0);
  807.             if (*cp==82)Quit=TRUE;
  808.             if ((*cp>=-96 && *cp<0) | (*cp>=32 && *cp<127))
  809.             {
  810.                 nslib_Writeio(cp,1);
  811.                 bp[pos]=*cp;
  812.                 pos++;
  813.             }
  814.         }
  815.         bp[pos+1]=0;
  816.         StrToLong((STRPTR)bp,longbuffer);
  817.         cport->CurserY=(char)*longbuffer;
  818.         if (cport->CurserY<10)
  819.         {
  820.             StrToLong((STRPTR)&bp[2],longbuffer);
  821.             cport->CurserX=(char)*longbuffer;
  822.         }
  823.         else
  824.         {
  825.             StrToLong((STRPTR)&bp[3],longbuffer);
  826.             cport->CurserX=(char)*longbuffer;
  827.         }
  828.     }
  829. }
  830.  
  831. __saveds ASM void nslib_FreeMsg(REG(a0) message *msg)
  832. {
  833. /*    if (msg->ln_Succ)
  834.     {
  835.         msg->ln_Succ->ln_Pred=msg->ln_Pred;
  836.     }
  837.     else
  838.     {
  839.         msg_list->last=msg->ln_Pred;
  840.     }
  841.     if (msg->ln_Pred)
  842.     {
  843.         msg->ln_Pred->ln_Succ=msg->ln_Succ;
  844.     }
  845.     else
  846.     {
  847.         msg_list->first=msg->ln_Succ;
  848.     }*/
  849.     if (msg->data_len>0)MyFreeVec(msg->data,"FREE IO_Global, FreeMsg(), msg->data");
  850.     MyFreeVec(msg,"FREE IOGlobal: FreeMsg, msg");
  851. }
  852.  
  853. __saveds ASM void nslib_ReturnMsg(REG(a0) message *msg)
  854. {
  855.     msg->msg_type=MSG_REPLY;
  856.     ReplyMsg((Message *)msg);
  857. }
  858.  
  859. __saveds ASM void nslib_ClearIOBuffer()
  860. {
  861. }
  862.  
  863. __saveds ASM void nslib_vioprintf(REG(a0) char *formatstring, REG(a1) char *args)
  864. {
  865.     char *buffer=AllocVec(10000,MEMF_ANY);
  866.     if (buffer)
  867.     {
  868.         vsprintf(buffer, formatstring, unsigned int(args));
  869.         nslib_Writeio(buffer,-1);
  870.         FreeVec(buffer);
  871.     }
  872. }
  873.  
  874. __saveds ASM void nslib_PrintDosError(REG(d0) const LONG errorcode)
  875. {
  876.     char buffer[FAULT_MAX];
  877.     Fault((LONG)errorcode,NULL,buffer,FAULT_MAX);
  878.     ioprintf("DOS-Error  %d: %s\n",errorcode,buffer);
  879. }
  880.  
  881. __saveds ASM MainPortConfig * nslib_getmainportconfig()
  882. {
  883.     return(mainportconfig);
  884. }